```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>JVM中的线程与并发管理 | 技术小馆</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Hiragino Sans GB", Simsun, sans-serif;
            line-height: 1.8;
            color: #333;
            background-color: #f8fafc;
        }
        .hero {
            background: linear-gradient(135deg, #1e3a8a 0%, #2563eb 100%);
        }
        .drop-cap:first-letter {
            float: left;
            font-size: 4.5rem;
            line-height: 0.9;
            margin: 0.2em 0.5rem 0.1em 0;
            font-weight: 700;
            color: #1e40af;
        }
        .code-block {
            background-color: #1e293b;
            color: #f8fafc;
            border-radius: 0.5rem;
            overflow-x: auto;
        }
        .nav-link {
            position: relative;
        }
        .nav-link::after {
            content: '';
            position: absolute;
            bottom: -2px;
            left: 0;
            width: 0;
            height: 2px;
            background-color: #3b82f6;
            transition: width 0.3s ease;
        }
        .nav-link:hover::after {
            width: 100%;
        }
        .card-hover {
            transition: transform 0.3s ease, box-shadow 0.3s ease;
        }
        .card-hover:hover {
            transform: translateY(-5px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .diagram-container {
            background-color: white;
            border-radius: 0.5rem;
            padding: 1.5rem;
            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
        }
    </style>
</head>
<body class="antialiased">
    <!-- Hero Section -->
    <section class="hero text-white py-20 md:py-32 px-4 md:px-0">
        <div class="container mx-auto max-w-5xl flex flex-col items-center text-center">
            <div class="inline-block px-3 py-1 mb-4 text-sm font-semibold text-blue-100 bg-blue-800 rounded-full">
                <i class="fas fa-microchip mr-2"></i>Java 并发编程
            </div>
            <h1 class="text-4xl md:text-6xl font-bold mb-6 font-serif">JVM中的线程与并发管理</h1>
            <p class="text-xl md:text-2xl max-w-3xl leading-relaxed opacity-90">
                探索Java虚拟机如何高效管理线程与并发，构建高性能、高可靠的多线程应用
            </p>
            <div class="mt-10 flex space-x-4">
                <a href="#content" class="px-6 py-3 bg-white text-blue-600 font-medium rounded-lg hover:bg-blue-50 transition duration-300 flex items-center">
                    <i class="fas fa-book-open mr-2"></i>开始阅读
                </a>
                <a href="#diagram" class="px-6 py-3 border border-white text-white font-medium rounded-lg hover:bg-white hover:bg-opacity-10 transition duration-300 flex items-center">
                    <i class="fas fa-project-diagram mr-2"></i>查看图解
                </a>
            </div>
        </div>
    </section>

    <!-- Navigation -->
    <nav class="sticky top-0 z-10 bg-white shadow-sm">
        <div class="container mx-auto max-w-5xl px-4">
            <div class="flex overflow-x-auto py-4 space-x-6 hide-scrollbar">
                <a href="#intro" class="nav-link text-gray-700 hover:text-blue-600 whitespace-nowrap"><i class="fas fa-info-circle mr-2"></i>概述</a>
                <a href="#basics" class="nav-link text-gray-700 hover:text-blue-600 whitespace-nowrap"><i class="fas fa-cubes mr-2"></i>线程基础</a>
                <a href="#model" class="nav-link text-gray-700 hover:text-blue-600 whitespace-nowrap"><i class="fas fa-sitemap mr-2"></i>线程模型</a>
                <a href="#scheduling" class="nav-link text-gray-700 hover:text-blue-600 whitespace-nowrap"><i class="fas fa-clock mr-2"></i>线程调度</a>
                <a href="#sync" class="nav-link text-gray-700 hover:text-blue-600 whitespace-nowrap"><i class="fas fa-lock mr-2"></i>线程同步</a>
                <a href="#pool" class="nav-link text-gray-700 hover:text-blue-600 whitespace-nowrap"><i class="fas fa-tasks mr-2"></i>线程池</a>
                <a href="#issues" class="nav-link text-gray-700 hover:text-blue-600 whitespace-nowrap"><i class="fas fa-exclamation-triangle mr-2"></i>常见问题</a>
            </div>
        </div>
    </nav>

    <!-- Main Content -->
    <main class="container mx-auto max-w-5xl px-4 py-12" id="content">
        <!-- Introduction Section -->
        <section id="intro" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="h-px flex-1 bg-gray-300"></div>
                <h2 class="text-3xl font-bold px-4 font-serif">概述</h2>
                <div class="h-px flex-1 bg-gray-300"></div>
            </div>
            <div class="prose max-w-none">
                <p class="drop-cap text-lg leading-relaxed">
                    无论是在单机应用，还是在分布式系统中，如何高效、安全地管理线程与并发，都是我们开发高性能Java应用的关键。理解JVM如何管理和调度线程，不仅能够帮助我们写出更加高效的代码，还能有效地避免在并发编程中常见的各种问题，如死锁、竞态条件和资源竞争等。
                </p>
                <div class="mt-8 rounded-xl overflow-hidden">
                    <img src="https://cdn.nlark.com/yuque/0/2025/png/21449790/1737351231011-2fcd7328-f7d9-479a-9fe0-0530b9794f53.png" alt="JVM线程管理" class="w-full h-auto">
                </div>
                <p class="mt-6 text-lg leading-relaxed">
                    JVM作为Java程序的运行时环境，在处理多线程时，提供了非常强大的支持。它不仅负责线程的创建、调度与销毁，还承担着线程同步、内存共享、以及线程间通信等多方面的工作。我们将从JVM的线程模型谈起，了解JVM如何创建与调度线程，如何保证线程之间的数据一致性与内存可见性，及其如何通过锁和并发工具保证程序的线程安全。
                </p>
            </div>
        </section>

        <!-- Thread Basics Section -->
        <section id="basics" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="h-px flex-1 bg-gray-300"></div>
                <h2 class="text-3xl font-bold px-4 font-serif">JVM中的线程基础</h2>
                <div class="h-px flex-1 bg-gray-300"></div>
            </div>
            <div class="prose max-w-none">
                <p class="text-lg leading-relaxed">
                    JVM中的线程基础涵盖了Java虚拟机如何创建、管理和调度线程，如何实现线程间的并发执行，以及如何与底层操作系统交互。
                </p>
                <div class="mt-8 rounded-xl overflow-hidden">
                    <img src="https://cdn.nlark.com/yuque/0/2025/png/21449790/1737351307800-728d0d52-66a2-4e35-abd2-409201015f2f.png" alt="JVM线程基础" class="w-full h-auto">
                </div>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>线程的定义与作用
                </h3>
                <ul class="list-disc pl-6 space-y-2">
                    <li>线程是程序执行的最小单位。每个Java应用至少包含一个线程，通常是主线程（main thread）。线程在运行时与其他线程共享同一个内存空间，这使得线程间可以共享数据。</li>
                    <li>在JVM中，线程的管理依赖于操作系统的线程模型，大多数JVM实现基于本地线程（Native Thread），这些线程直接映射到操作系统的线程上。</li>
                </ul>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>线程的生命周期
                </h3>
                <p>JVM中的线程生命周期包括五个状态：</p>
                <div class="grid md:grid-cols-2 lg:grid-cols-5 gap-4 mt-6">
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 text-center card-hover">
                        <div class="text-blue-500 text-4xl mb-3"><i class="fas fa-plus-circle"></i></div>
                        <h4 class="font-bold">新建 (New)</h4>
                        <p class="text-sm text-gray-600">线程对象被创建，但尚未启动</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 text-center card-hover">
                        <div class="text-green-500 text-4xl mb-3"><i class="fas fa-toggle-on"></i></div>
                        <h4 class="font-bold">就绪 (Runnable)</h4>
                        <p class="text-sm text-gray-600">线程已准备好运行，等待CPU时间片</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 text-center card-hover">
                        <div class="text-purple-500 text-4xl mb-3"><i class="fas fa-play-circle"></i></div>
                        <h4 class="font-bold">运行中 (Running)</h4>
                        <p class="text-sm text-gray-600">线程正在执行中</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 text-center card-hover">
                        <div class="text-yellow-500 text-4xl mb-3"><i class="fas fa-pause-circle"></i></div>
                        <h4 class="font-bold">阻塞 (Blocked)</h4>
                        <p class="text-sm text-gray-600">线程因等待资源而被阻塞</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 text-center card-hover">
                        <div class="text-red-500 text-4xl mb-3"><i class="fas fa-stop-circle"></i></div>
                        <h4 class="font-bold">终止 (Terminated)</h4>
                        <p class="text-sm text-gray-600">线程执行完毕或被强制停止</p>
                    </div>
                </div>
                <p class="mt-6">JVM的线程生命周期模型与操作系统密切相关，JVM通过线程调度器与操作系统协作来实现线程的生命周期管理。</p>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>线程的创建
                </h3>
                <p>在JVM中，线程的创建有两种常见方式：</p>
                <div class="grid md:grid-cols-2 gap-6 mt-6">
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold text-lg flex items-center">
                            <i class="fas fa-code-branch text-blue-500 mr-2"></i>继承Thread类
                        </h4>
                        <p class="mt-2">通过创建一个继承Thread类的子类，并重写其<code>run()</code>方法来定义线程的执行内容。</p>
                        <div class="code-block mt-4 p-4 rounded">
                            <pre class="text-sm overflow-x-auto"><code class="language-java">// 继承Thread类
class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running");
    }
}</code></pre>
                        </div>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold text-lg flex items-center">
                            <i class="fas fa-project-diagram text-blue-500 mr-2"></i>实现Runnable接口
                        </h4>
                        <p class="mt-2">通过实现<code>Runnable</code>接口并重写<code>run()</code>方法来定义线程的执行内容。</p>
                        <div class="code-block mt-4 p-4 rounded">
                            <pre class="text-sm overflow-x-auto"><code class="language-java">// 使用Runnable接口
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread is running");
    }
}</code></pre>
                        </div>
                    </div>
                </div>
                <p class="mt-6">示例代码：</p>
                <div class="code-block mt-2 p-4 rounded">
                    <pre class="text-sm overflow-x-auto"><code class="language-java">public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start(); // 启动线程

        Thread t2 = new Thread(new MyRunnable());
        t2.start(); // 启动线程
    }
}</code></pre>
                </div>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>线程的调度
                </h3>
                <p>JVM的线程调度是基于操作系统的调度机制实现的。Java通过多种方式影响线程的调度：</p>
                <div class="grid md:grid-cols-3 gap-4 mt-6">
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-moon text-blue-500 mr-2"></i>Thread.sleep()
                        </h4>
                        <p class="mt-2 text-sm">使当前线程休眠一段时间，暂停其执行，释放CPU资源。</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-exchange-alt text-blue-500 mr-2"></i>Thread.yield()
                        </h4>
                        <p class="mt-2 text-sm">提示操作系统当前线程愿意让出CPU资源，但操作系统并不一定会立即调度其他线程。</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-handshake text-blue-500 mr-2"></i>Thread.join()
                        </h4>
                        <p class="mt-2 text-sm">使当前线程等待其他线程完成执行后再继续。</p>
                    </div>
                </div>
                <p class="mt-6">线程调度策略大体可以分为：</p>
                <div class="grid md:grid-cols-2 gap-6 mt-4">
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100">
                        <h4 class="font-bold">时间片轮转</h4>
                        <p class="mt-2">每个线程被分配一个时间片，执行一定时间后会被操作系统挂起，等待下一次执行。</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100">
                        <h4 class="font-bold">优先级调度</h4>
                        <p class="mt-2">不同线程可能有不同的优先级，操作系统根据优先级来分配CPU时间。</p>
                    </div>
                </div>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>线程同步与共享资源
                </h3>
                <p>多个线程可能会共享资源，因此需要一种机制来控制多个线程对共享资源的访问，避免出现数据一致性问题。这就引入了线程同步的概念。</p>
                <div class="grid md:grid-cols-3 gap-4 mt-6">
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-lock text-blue-500 mr-2"></i>同步方法
                        </h4>
                        <p class="mt-2 text-sm">可以通过<code>synchronized</code>关键字修饰方法，确保一个线程在执行该方法时，其他线程无法同时执行该方法。</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-code text-blue-500 mr-2"></i>同步块
                        </h4>
                        <p class="mt-2 text-sm"><code>synchronized</code>也可以用来修饰代码块，限定同步范围，减少锁的粒度，提高并发性能。</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-key text-blue-500 mr-2"></i>锁机制
                        </h4>
                        <p class="mt-2 text-sm">除了<code>synchronized</code>关键字，Java还提供了显式锁（如<code>ReentrantLock</code>），用于更细粒度的控制。</p>
                    </div>
                </div>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>线程池
                </h3>
                <p>在JVM中，线程池是管理线程的一种方式，通过线程池来避免频繁的线程创建与销毁开销，提高资源利用率。Java提供了<code>ExecutorService</code>接口及其实现类（如<code>ThreadPoolExecutor</code>），来高效地管理和调度线程。</p>
                <p class="mt-4">使用线程池的好处：</p>
                <ul class="list-disc pl-6 space-y-2">
                    <li>重用线程，避免频繁创建销毁线程的开销。</li>
                    <li>提高线程管理的灵活性，可以控制最大线程数。</li>
                    <li>简化线程管理和任务提交的过程。</li>
                </ul>
                <p class="mt-4">示例代码：</p>
                <div class="code-block mt-2 p-4 rounded">
                    <pre class="text-sm overflow-x-auto"><code class="language-java">ExecutorService executor = Executors.newFixedThreadPool(10);  // 创建线程池
executor.submit(() -> {
    System.out.println("Task is running");
});
executor.shutdown();  // 关闭线程池</code></pre>
                </div>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>线程的中断与停止
                </h3>
                <div class="grid md:grid-cols-2 gap-4 mt-4">
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100">
                        <h4 class="font-bold">Thread.interrupt()</h4>
                        <p class="mt-2 text-sm">通过调用<code>interrupt()</code>方法通知线程中断，线程可以根据需要自行处理中断标志，进行相应的清理工作。</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100">
                        <h4 class="font-bold">Thread.stop()</h4>
                        <p class="mt-2 text-sm">不推荐使用，因其可能导致资源未正确释放或不一致的状态。</p>
                    </div>
                </div>
                <p class="mt-6">
                    通过掌握JVM中的线程基础知识，我们可以更好地理解和控制Java应用中的并发执行，提升程序的性能与可靠性。对于复杂的并发应用，合理的线程管理将直接影响系统的响应速度和稳定性。
                </p>
            </div>
        </section>

        <!-- Thread Model Section -->
        <section id="model" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="h-px flex-1 bg-gray-300"></div>
                <h2 class="text-3xl font-bold px-4 font-serif">JVM的线程模型</h2>
                <div class="h-px flex-1 bg-gray-300"></div>
            </div>
            <div class="prose max-w-none">
                <p class="text-lg leading-relaxed">
                    JVM的线程模型是Java虚拟机管理和调度线程执行的机制，主要涉及线程的创建、调度、执行与销毁。JVM的线程模型与操作系统的底层线程模型密切相关，但在实现细节上有一些特有的管理方式。了解JVM的线程模型，有助于开发者在多线程程序设计时优化性能、避免潜在的并发问题。
                </p>
                <div class="mt-8 rounded-xl overflow-hidden">
                    <img src="https://cdn.nlark.com/yuque/0/2025/png/21449790/1737351342416-efc1a89c-5fc0-4490-aa3b-fc9907c04ff2.png" alt="JVM线程模型" class="w-full h-auto">
                </div>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>线程的创建与生命周期
                </h3>
                <p>在JVM中，线程的生命周期由Java线程类（<code>Thread</code>）来管理，它表示Java虚拟机中的一个线程。JVM的线程生命周期大致分为以下几个阶段：</p>
                <ul class="list-disc pl-6 space-y-2 mt-4">
                    <li><strong>新建（New）</strong>：线程对象被创建，但尚未启动。此时线程没有开始执行，仍处于未就绪状态。</li>
                    <li><strong>就绪（Runnable）</strong>：线程准备就绪，等待操作系统的线程调度器分配CPU资源。需要注意，Java中的"就绪"状态与操作系统的"运行中"状态是不同的，Java线程在此状态下仍有可能被挂起，直到操作系统的调度器允许它获得CPU时间。</li>
                    <li><strong>运行中（Running）</strong>：线程获得CPU资源后，进入运行状态，执行任务。这个状态的线程会被操作系统调度器分配到实际的CPU核心上执行。</li>
                    <li><strong>阻塞（Blocked）</strong>：当线程需要等待某个资源（如锁）时，它会进入阻塞状态，直到获得所需资源才能继续执行。</li>
                    <li><strong>终止（Terminated）</strong>：线程执行完毕或者被强制停止后进入终止状态，不再参与调度。</li>
                </ul>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>线程调度模型
                </h3>
                <p>JVM中的线程调度依赖于操作系统提供的底层线程调度机制。Java通过以下方式控制线程的执行：</p>
                <ul class="list-disc pl-6 space-y-2 mt-4">
                    <li><strong>时间片轮转</strong>：操作系统为每个线程分配一个时间片，每个线程在时间片内运行，当时间片耗尽后，操作系统会挂起当前线程并选择其他线程执行。Java中的线程调度通常基于这个策略。</li>
                    <li><strong>线程优先级</strong>：Java线程支持设置线程优先级，虽然操作系统的线程调度器并不总是根据优先级来调度线程，但Java允许开发者设定线程优先级，以提示调度器优先调度某些线程。线程的优先级通常有10个级别（<code>Thread.MIN_PRIORITY</code>到<code>Thread.MAX_PRIORITY</code>），默认优先级为<code>Thread.NORM_PRIORITY</code>。</li>
                    <li><code>Thread.sleep()</code>：调用<code>Thread.sleep(long millis)</code>会使当前线程暂停执行指定的毫秒数，并释放CPU资源，其他线程可以被调度执行。虽然线程休眠期间，它仍然保持"就绪"状态，但不会占用CPU资源。</li>
                    <li><code>Thread.yield()</code>：调用<code>Thread.yield()</code>提示操作系统让出CPU资源，当前线程会将CPU控制权交给同一优先级的其他线程，但操作系统不一定会立即执行其他线程。</li>
                    <li><code>Thread.join()</code>：调用<code>join()</code>方法会使当前线程等待指定线程执行完毕后再继续执行。这个方法常用于线程之间的协调与同步。</li>
                </ul>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>JVM的线程模型与操作系统的交互
                </h3>
                <p>尽管JVM提供了一些控制线程调度的手段，但线程调度的最终决策仍然由操作系统来做。JVM的线程调度通常是基于操作系统的线程调度器（如Linux的<code>pthread</code>线程库、Windows的<code>Win32</code>线程库）。这意味着：</p>
                <ul class="list-disc pl-6 space-y-2 mt-4">
                    <li>JVM中的线程通常是操作系统线程的封装。每个Java线程对应一个操作系统线程（即JVM中的每个线程与操作系统的线程1:1映射）。</li>
                    <li>JVM调度只是对操作系统线程调度的补充，操作系统的线程调度通常使用基于优先级或时间片轮转的策略。</li>
                    <li>JVM的线程调度无法改变操作系统的底层调度方式，但可以通过优化线程的创建、启动、终止及任务的分配来提高系统的并发性能。</li>
                </ul>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>JVM的线程安全与内存模型
                </h3>
                <p>JVM的线程安全性与内存模型（Java Memory Model, JMM）密切相关。JMM定义了不同线程之间如何共享和可见数据的规则，以确保程序在多线程环境下的正确性。</p>
                <ul class="list-disc pl-6 space-y-2 mt-4">
                    <li><strong>共享变量</strong>：Java中的所有对象和类的成员变量都可以被多个线程共享。当多个线程访问同一个共享变量时，可能会发生"内存可见性"问题，导致线程读取到过时的值。为了避免此类问题，JVM保证了对共享变量的操作必须符合一定的内存可见性规则。</li>
                    <li><code>volatile</code>关键字：<code>volatile</code>关键字保证了变量的值在多个线程中是可见的，即当一个线程修改了变量的值，其他线程可以立刻看到最新的值。</li>
                    <li><code>synchronized</code>与锁机制：JVM通过同步块（<code>synchronized</code>）或显式锁（如<code>ReentrantLock</code>）来保证对共享资源的访问是互斥的。通过锁机制，JVM能够确保在任意时刻，只有一个线程能够访问临界区代码。</li>
                    <li><strong>原子性操作</strong>：为了避免线程在操作共享变量时出现竞争条件，JVM提供了多种原子性操作（如<code>AtomicInteger</code>），这些操作保证了对变量的更新是不可分割的。</li>
                </ul>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>JVM的线程池管理
                </h3>
                <p>线程池是JVM提供的高效管理线程的工具。线程池通过复用现有的线程来减少线程创建和销毁的开销，从而提高系统性能。Java的<code>java.util.concurrent</code>包提供了多种线程池实现，如<code>FixedThreadPool</code>、<code>CachedThreadPool</code>等。</p>
                <ul class="list-disc pl-6 space-y-2 mt-4">
                    <li><strong>线程池的工作原理</strong>：线程池的主要工作机制是任务队列。当有任务提交到线程池时，如果线程池中有空闲线程，任务会直接分配给空闲线程；如果没有空闲线程，任务会放入任务队列中等待，直到有线程空闲时处理。</li>
                    <li><strong>线程池的管理</strong>：通过<code>ExecutorService</code>接口，JVM提供了对线程池的管理，包括任务的提交、关闭线程池、以及线程池中线程的管理等。</li>
                </ul>
            </div>
        </section>

        <!-- Thread Scheduling Section -->
        <section id="scheduling" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="h-px flex-1 bg-gray-300"></div>
                <h2 class="text-3xl font-bold px-4 font-serif">JVM中的线程调度</h2>
                <div class="h-px flex-1 bg-gray-300"></div>
            </div>
            <div class="prose max-w-none">
                <p class="text-lg leading-relaxed">
                    线程调度是多线程程序设计中的一个核心概念，指的是操作系统和JVM如何管理多个线程的执行顺序。Java虚拟机（JVM）提供了多线程的支持，但最终的线程调度仍然依赖于底层操作系统。JVM线程调度的目标是使得多个线程能够有效地共享CPU资源，同时保证程序的正确性和高效性。
                </p>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>JVM中的线程调度机制
                </h3>
                <p>JVM中的线程调度基于操作系统的线程管理，但通过一定的调度策略，控制线程的执行顺序。JVM中的线程调度主要由以下几个方面组成：</p>
                <ul class="list-disc pl-6 space-y-2 mt-4">
                    <li><strong>线程的创建与启动</strong>：Java通过<code>Thread</code>类的<code>start()</code>方法来启动一个新线程。当调用<code>start()</code>时，JVM会将该线程加入到操作系统的线程调度队列中，操作系统会根据其调度策略选择合适的线程来执行。</li>
                    <li><strong>线程的生命周期管理</strong>：线程在不同状态间切换（如从"就绪"到"运行"状态），JVM通过底层的线程库与操作系统进行交互，控制线程的切换。操作系统会负责分配CPU时间片，JVM通过一定的逻辑来确保线程的高效调度。</li>
                </ul>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>线程调度的策略
                </h3>
                <p>JVM的线程调度策略通常会受操作系统调度器的影响，操作系统采用不同的调度策略来管理线程。常见的线程调度策略有：</p>
                <div class="grid md:grid-cols-2 gap-6 mt-6">
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-history text-blue-500 mr-2"></i>时间片轮转 (Round Robin Scheduling)
                        </h4>
                        <p class="mt-2">操作系统将CPU时间分配给各个线程，通常是按顺序分配固定的时间片（time slice）。当时间片用尽时，线程会被挂起，操作系统调度器会把CPU分配给下一个线程。</p>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-trophy text-blue-500 mr-2"></i>优先级调度 (Priority Scheduling)
                        </h4>
                        <p class="mt-2">线程优先级是JVM调度的一个重要因素。操作系统根据线程的优先级来决定调度顺序。JVM允许开发者通过<code>Thread.setPriority(int priority)</code>来设置线程的优先级。</p>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-bolt text-blue-500 mr-2"></i>抢占式调度 (Preemptive Scheduling)
                        </h4>
                        <p class="mt-2">当一个线程正在运行时，操作系统可以通过抢占策略（例如，线程的优先级更高）来中断它，迫使它放弃CPU时间，使其他线程得到执行。这通常是在多核处理器环境下使用的一种调度策略。</p>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-pause-circle text-blue-500 mr-2"></i>非抢占式调度 (Non-preemptive Scheduling)
                        </h4>
                        <p class="mt-2">线程一旦获取到CPU资源，就会一直运行下去，直到它主动释放CPU资源（如完成任务或调用<code>Thread.sleep()</code>）。在这种调度方式下，操作系统无法强制挂起正在运行的线程。</p>
                    </div>
                </div>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>JVM对线程调度的控制
                </h3>
                <p>JVM对线程调度提供了一些控制手段，主要体现在以下几个方面：</p>
                <div class="grid md:grid-cols-2 gap-6 mt-6">
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-sliders-h text-blue-500 mr-2"></i>线程优先级
                        </h4>
                        <p class="mt-2">Java线程支持设置优先级。通过<code>Thread.setPriority(int priority)</code>方法可以设置线程的优先级，优先级越高，线程越容易被调度执行。然而，优先级调度的效果在不同的操作系统上可能有所不同。</p>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-bed text-blue-500 mr-2"></i>线程睡眠与挂起
                        </h4>
                        <p class="mt-2">通过调用<code>Thread.sleep(long millis)</code>可以使当前线程暂停执行指定的时间，释放CPU资源，允许其他线程执行。<code>Thread.sleep()</code>并不会中断线程的执行，只是让线程进入休眠状态。</p>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-hand-holding text-blue-500 mr-2"></i>Thread.yield()
                        </h4>
                        <p class="mt-2">调用<code>Thread.yield()</code>方法时，当前线程建议操作系统放弃当前时间片，允许其他同等优先级的线程获得CPU资源。操作系统不一定会立即调度其他线程。</p>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-link text-blue-500 mr-2"></i>Thread.join()
                        </h4>
                        <p class="mt-2"><code>join()</code>方法使当前线程等待被调用的线程执行完毕后再继续执行。这个方法通常用于实现线程间的协调，确保线程按顺序执行。</p>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 md:col-span-2">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-users-cog text-blue-500 mr-2"></i>线程池
                        </h4>
                        <p class="mt-2">在JVM中，线程池是管理线程的一种重要机制。线程池的作用是通过复用线程来避免频繁创建和销毁线程的开销，同时避免线程过多导致资源耗尽。Java的<code>ExecutorService</code>接口提供了各种线程池实现（如<code>FixedThreadPool</code>、<code>CachedThreadPool</code>等），这些线程池会根据任务队列的情况动态管理线程的创建与销毁。</p>
                    </div>
                </div>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>线程调度的常见问题
                </h3>
                <div class="grid md:grid-cols-3 gap-4 mt-6">
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-hourglass-half text-yellow-500 mr-2"></i>线程饥饿
                        </h4>
                        <p class="mt-2 text-sm">当某个线程总是得不到足够的CPU时间而无法执行时，可能会导致线程饥饿问题。通常与线程优先级设置不当或调度策略的设计有关。</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-unlink text-red-500 mr-2"></i>线程死锁
                        </h4>
                        <p class="mt-2 text-sm">当多个线程在相互等待对方释放资源时，可能会发生死锁，导致程序的无限期挂起。为了解决这个问题，Java提供了多种同步机制。</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold flex items-center">
                            <i class="fas fa-exchange-alt text-purple-500 mr-2"></i>上下文切换开销
                        </h4>
                        <p class="mt-2 text-sm">当操作系统频繁地切换不同的线程时，可能会产生上下文切换开销，降低程序的性能。为了避免频繁的线程切换，可以合理地选择线程数、使用线程池。</p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Thread Synchronization Section -->
        <section id="sync" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="h-px flex-1 bg-gray-300"></div>
                <h2 class="text-3xl font-bold px-4 font-serif">线程同步机制</h2>
                <div class="h-px flex-1 bg-gray-300"></div>
            </div>
            <div class="prose max-w-none">
                <p class="text-lg leading-relaxed">
                    线程同步是多线程编程中为了保证多个线程在共享资源时不产生冲突而采取的一系列机制。由于多个线程可能会同时访问共享的资源（如内存中的数据），如果没有适当的同步措施，会导致数据的不一致或程序行为不可预测。因此，Java提供了多种同步机制来确保线程安全。
                </p>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>同步的基本概念
                </h3>
                <p>同步的核心目的是确保在同一时刻，只有一个线程可以访问共享资源，其他线程需要等待。这通过引入锁的机制来实现。常见的同步概念包括：</p>
                <ul class="list-disc pl-6 space-y-2 mt-4">
                    <li><strong>临界区（Critical Section）</strong>：程序中对共享资源进行读写的部分。多个线程访问时，可能会发生数据冲突，因此需要同步。</li>
                    <li><strong>锁（Lock）</strong>：同步机制的基础。线程通过获取锁来控制对共享资源的访问，其他线程在锁释放前无法访问这些资源。</li>
                </ul>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>Java中的同步机制
                </h3>
                <p>Java提供了多种同步机制来解决并发问题，常见的同步方式包括：</p>

                <h4 class="text-xl font-bold mt-6 flex items-center">
                    <i class="fas fa-lock text-blue-500 mr-2"></i>synchronized 关键字
                </h4>
                <p><code>synchronized</code> 是Java最基本的同步机制。它可以用来修饰方法或代码块，以确保同一时刻只有一个线程可以执行被修饰的代码。</p>
                <div class="grid md:grid-cols-2 gap-6 mt-4">
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100">
                        <h5 class="font-bold">方法同步</h5>
                        <p class="mt-2 text-sm">通过在方法声明中添加 <code>synchronized</code> 关键字来实现同步。它会锁定整个方法（即锁住当前对象）。</p>
                        <div class="code-block mt-3 p-3 rounded">
                            <pre class="text-xs overflow-x-auto"><code class="language-java">public synchronized void increment() {
    count++;
}</code></pre>
                        </div>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100">
                        <h5 class="font-bold">代码块同步</h5>
                        <p class="mt-2 text-sm">使用 <code>synchronized</code> 关键字对代码块进行同步，可以更加精细地控制锁的粒度。</p>
                        <div class="code-block mt-3 p-3 rounded">
                            <pre class="text-xs overflow-x-auto"><code class="language-java">public void increment() {
    synchronized(this) {
        count++;
    }
}</code></pre>
                        </div>
                    </div>
                </div>

                <h4 class="text-xl font-bold mt-6 flex items-center">
                    <i class="fas fa-bolt text-blue-500 mr-2"></i>volatile 关键字
                </h4>
                <p><code>volatile</code> 关键字保证了变量的值在多个线程中是可见的，即当一个线程修改了变量的值，其他线程可以立刻看到最新的值。然而，<code>volatile</code> 只能确保可见性，无法保证原子性和互斥性。</p>
                <div class="code-block mt-4 p-4 rounded">
                    <pre class="text-sm overflow-x-auto"><code class="language-java">private volatile boolean flag = false;

public void setFlagTrue() {
    flag = true;
}

public boolean isFlagTrue() {
    return flag;
}</code></pre>
                </div>

                <h4 class="text-xl font-bold mt-6 flex items-center">
                    <i class="fas fa-key text-blue-500 mr-2"></i>Lock 接口
                </h4>
                <p>Java的 <code>java.util.concurrent.locks</code> 包提供了比 <code>synchronized</code> 更强大的锁机制。<code>Lock</code> 接口提供了更细粒度的锁控制。</p>
                <div class="grid md:grid-cols-2 gap-6 mt-4">
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100">
                        <h5 class="font-bold">ReentrantLock</h5>
                        <p class="mt-2 text-sm">支持可重入锁、锁的公平性、尝试获取锁等特性。</p>
                        <div class="code-block mt-3 p-3 rounded">
                            <pre class="text-xs overflow-x-auto"><code class="language-java">ReentrantLock lock = new ReentrantLock();

public void increment() {
    lock.lock();
    try {
        count++;
    } finally {
        lock.unlock();  // 保证释放锁
    }
}</code></pre>
                        </div>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100">
                        <h5 class="font-bold">Fair Lock</h5>
                        <p class="mt-2 text-sm"><code>ReentrantLock</code> 可以通过构造函数设定是否为公平锁（默认是非公平锁）。公平锁按请求的顺序分配锁。</p>
                        <div class="code-block mt-3 p-3 rounded">
                            <pre class="text-xs overflow-x-auto"><code class="language-java">ReentrantLock fairLock = new ReentrantLock(true); // 公平锁</code></pre>
                        </div>
                    </div>
                </div>

                <h4 class="text-xl font-bold mt-6 flex items-center">
                    <i class="fas fa-book-reader text-blue-500 mr-2"></i>读写锁（Read-Write Lock）
                </h4>
                <p>读写锁是 <code>Lock</code> 接口的扩展，允许多个线程同时读取共享资源，但写操作必须独占访问。</p>
                <div class="code-block mt-4 p-4 rounded">
                    <pre class="text-sm overflow-x-auto"><code class="language-java">ReadWriteLock rwLock = new ReentrantReadWriteLock();
Lock readLock = rwLock.readLock();
Lock writeLock = rwLock.writeLock();

public void read() {
    readLock.lock();
    try {
        // 执行读取操作
    } finally {
        readLock.unlock();
    }
}

public void write() {
    writeLock.lock();
    try {
        // 执行写操作
    } finally {
        writeLock.unlock();
    }
}</code></pre>
                </div>

                <h4 class="text-xl font-bold mt-6 flex items-center">
                    <i class="fas fa-traffic-light text-blue-500 mr-2"></i>Semaphore（信号量）
                </h4>
                <p><code>Semaphore</code> 是一种计数信号量，用于控制访问特定资源的线程数量。</p>
                <div class="code-block mt-4 p-4 rounded">
                    <pre class="text-sm overflow-x-auto"><code class="language-java">Semaphore semaphore = new Semaphore(3);  // 限制最大同时访问线程数为3

public void accessResource() {
    try {
        semaphore.acquire();  // 获取信号量
        // 访问共享资源
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        semaphore.release();  // 释放信号量
    }
}</code></pre>
                </div>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>线程安全的容器和类
                </h3>
                <p>Java还提供了许多内置的线程安全容器和类，这些类内部已经实现了同步机制，用于在多线程环境下安全地操作数据。例如：</p>
                <div class="grid md:grid-cols-2 gap-4 mt-4">
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100">
                        <h4 class="font-bold">ConcurrentHashMap</h4>
                        <p class="mt-2 text-sm">支持高并发读写的线程安全HashMap实现。</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100">
                        <h4 class="font-bold">CopyOnWriteArrayList</h4>
                        <p class="mt-2 text-sm">线程安全的List，适用于读多写少的场景。</p>
                    </div>
                </div>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>同步与性能的平衡
                </h3>
                <p>虽然同步机制能够有效保证线程安全，但过度使用同步会带来性能开销。同步机制通过引入锁会导致线程等待，增加上下文切换和锁竞争的开销。在设计并发程序时，需要在保证线程安全和提高性能之间找到平衡。一般来说，减少锁的粒度、优化锁的竞争、使用无锁编程技术（如原子操作、CAS）等方式可以有效提升性能。</p>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>常见的同步问题
                </h3>
                <div class="grid md:grid-cols-2 gap-4 mt-4">
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100">
                        <h4 class="font-bold">死锁</h4>
                        <p class="mt-2 text-sm">多个线程在等待彼此持有的资源，形成环形依赖，导致程序无法继续执行。避免死锁的一种方法是按照固定顺序获取锁。</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100">
                        <h4 class="font-bold">线程饥饿</h4>
                        <p class="mt-2 text-sm">某些线程长时间无法获得执行机会，导致这些线程一直处于等待状态。公平锁可以有效避免线程饥饿问题。</p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Thread Pool Section -->
        <section id="pool" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="h-px flex-1 bg-gray-300"></div>
                <h2 class="text-3xl font-bold px-4 font-serif">JVM中的线程池管理</h2>
                <div class="h-px flex-1 bg-gray-300"></div>
            </div>
            <div class="prose max-w-none">
                <p class="text-lg leading-relaxed">
                    线程池是多线程编程中的一种优化机制，用于控制并发线程的数量，避免了频繁创建和销毁线程的开销，并能有效提高资源的利用率。在JVM中，线程池的管理是一个非常重要的性能优化点。Java提供了强大的线程池管理工具，尤其是在<code>java.util.concurrent</code>包下，<code>Executor</code>框架提供了线程池的标准实现。
                </p>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>线程池的概念
                </h3>
                <p>线程池是事先创建好的一组线程，它们用来执行任务。线程池的使用可以显著减少线程创建和销毁的开销，同时还能够限制线程的最大数量，避免由于过多线程竞争系统资源导致的性能下降。线程池通过合理的管理和调度线程，提升了系统的响应速度和处理能力。</p>

                <h4 class="text-xl font-bold mt-6">线程池的优势</h4>
                <ul class="list-disc pl-6 space-y-2">
                    <li><strong>性能提升</strong>：避免频繁创建和销毁线程的性能开销，重复利用线程池中的线程。</li>
                    <li><strong>资源管理</strong>：通过限制最大线程数，避免系统资源（如CPU、内存）被过度消耗。</li>
                    <li><strong>任务调度</strong>：线程池通常会内置任务调度策略，可以有效管理任务的执行顺序、并发数量等。</li>
                    <li><strong>线程复用</strong>：线程池中的线程是可复用的，可以避免频繁创建和销毁线程的资源浪费。</li>
                </ul>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>JVM中的线程池实现
                </h3>
                <p>Java提供了<code>Executor</code>框架作为线程池管理的核心组件，其中有几个常用的线程池实现。</p>

                <h4 class="text-xl font-bold mt-6">Executor接口</h4>
                <p><code>Executor</code>是线程池的核心接口，定义了线程池任务执行的基本方法。它的实现类负责管理线程池和任务的分配。</p>
                <div class="code-block mt-4 p-4 rounded">
                    <pre class="text-sm overflow-x-auto"><code class="language-java">public interface Executor {
    void execute(Runnable command);
}</code></pre>
                </div>

                <h4 class="text-xl font-bold mt-6">ExecutorService接口</h4>
                <p><code>ExecutorService</code>继承自<code>Executor</code>，增加了更多线程池的功能，如管理任务的生命周期、任务执行的调度等。常用的实现类包括<code>ThreadPoolExecutor</code>和<code>ScheduledThreadPoolExecutor</code>。</p>
                <div class="code-block mt-4 p-4 rounded">
                    <pre class="text-sm overflow-x-auto"><code class="language-java">public interface ExecutorService extends Executor {
    void shutdown();
    List<Runnable> shutdownNow();
    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks);
    <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;
}</code></pre>
                </div>

                <h4 class="text-xl font-bold mt-6">常见线程池实现</h4>
                <div class="grid md:grid-cols-2 gap-6 mt-4">
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h5 class="font-bold text-lg">ThreadPoolExecutor</h5>
                        <p class="mt-2">最常用的线程池实现类，提供了对线程池的全面控制，包括核心线程数、最大线程数、线程空闲时间等参数配置。</p>
                        <div class="code-block mt-4 p-4 rounded">
                            <pre class="text-xs overflow-x-auto"><code class="language-java">ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
    2,  // 核心线程数
    4,  // 最大线程数
    60, // 空闲线程存活时间
    TimeUnit.SECONDS, // 时间单位
    new LinkedBlockingQueue<>(10)  // 工作队列
);</code></pre>
                        </div>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h5 class="font-bold text-lg">ScheduledThreadPoolExecutor</h5>
                        <p class="mt-2">继承自<code>ThreadPoolExecutor</code>，支持定时和周期性任务的执行。它非常适合于需要定时调度任务的场景。</p>
                        <div class="code-block mt-4 p-4 rounded">
                            <pre class="text-xs overflow-x-auto"><code class="language-java">ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
scheduler.scheduleAtFixedRate(() -> 
    System.out.println("定时任务"), 0, 5, TimeUnit.SECONDS);</code></pre>
                        </div>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h5 class="font-bold text-lg">CachedThreadPool</h5>
                        <p class="mt-2">线程池中的线程数量是动态调整的，当任务增加时，线程池会增加新的线程；当线程空闲一段时间后，线程会被销毁。</p>
                        <div class="code-block mt-4 p-4 rounded">
                            <pre class="text-xs overflow-x-auto"><code class="language-java">ExecutorService cachedThreadPool = Executors.newCachedThreadPool();</code></pre>
                        </div>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h5 class="font-bold text-lg">FixedThreadPool</h5>
                        <p class="mt-2">固定大小的线程池，线程池中始终保持固定数量的线程。适用于处理任务数量较为固定且并发需求较大的场景。</p>
                        <div class="code-block mt-4 p-4 rounded">
                            <pre class="text-xs overflow-x-auto"><code class="language-java">ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);</code></pre>
                        </div>
                    </div>
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 md:col-span-2 card-hover">
                        <h5 class="font-bold text-lg">SingleThreadExecutor</h5>
                        <p class="mt-2">单线程池，只有一个线程来执行所有任务。适用于任务需要按顺序执行的场景。</p>
                        <div class="code-block mt-4 p-4 rounded">
                            <pre class="text-xs overflow-x-auto"><code class="language-java">ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();</code></pre>
                        </div>
                    </div>
                </div>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>线程池的核心参数
                </h3>
                <p>在<code>ThreadPoolExecutor</code>中，我们可以通过构造方法配置线程池的各个参数，具体参数的作用如下：</p>
                <div class="overflow-x-auto mt-4">
                    <table class="min-w-full bg-white border border-gray-200">
                        <thead>
                            <tr class="bg-gray-50">
                                <th class="px-4 py-2 border-b">参数</th>
                                <th class="px-4 py-2 border-b">说明</th>
                            </tr>
                        </thead>
                        <tbody>
                            <tr>
                                <td class="px-4 py-2 border-b">corePoolSize</td>
                                <td class="px-4 py-2 border-b">核心线程数，线程池保持的最小线程数量。如果线程池中的线程数小于核心线程数，即使没有任务，线程池也会创建新的线程。</td>
                            </tr>
                            <tr class="bg-gray-50">
                                <td class="px-4 py-2 border-b">maximumPoolSize</td>
                                <td class="px-4 py-2 border-b">最大线程数，线程池允许创建的最大线程数。如果当前线程池中的线程数大于或等于核心线程数，且队列已满，则会创建新的线程，直到达到最大线程数。</td>
                            </tr>
                            <tr>
                                <td class="px-4 py-2 border-b">keepAliveTime</td>
                                <td class="px-4 py-2 border-b">非核心线程的空闲存活时间。非核心线程在空闲时间达到指定值后会被回收。</td>
                            </tr>
                            <tr class="bg-gray-50">
                                <td class="px-4 py-2 border-b">TimeUnit</td>
                                <td class="px-4 py-2 border-b">指定<code>keepAliveTime</code>的时间单位。</td>
                            </tr>
                            <tr>
                                <td class="px-4 py-2 border-b">workQueue</td>
                                <td class="px-4 py-2 border-b">任务队列，存放等待执行的任务。常见的队列有<code>ArrayBlockingQueue</code>、<code>LinkedBlockingQueue</code>、<code>SynchronousQueue</code>等。</td>
                            </tr>
                            <tr class="bg-gray-50">
                                <td class="px-4 py-2 border-b">threadFactory</td>
                                <td class="px-4 py-2 border-b">用于创建新线程的工厂。可以通过自定义工厂来设置线程的名称、优先级等属性。</td>
                            </tr>
                            <tr>
                                <td class="px-4 py-2 border-b">handler</td>
                                <td class="px-4 py-2 border-b">当线程池中的线程数超过最大线程数时，如何处理新任务。常见的处理策略有：
                                    <ul class="list-disc pl-6 mt-2">
                                        <li><code>AbortPolicy</code>（默认策略）：直接抛出<code>RejectedExecutionException</code>异常。</li>
                                        <li><code>CallerRunsPolicy</code>：调用执行任务的线程来执行任务。</li>
                                        <li><code>DiscardPolicy</code>：直接丢弃任务。</li>
                                        <li><code>DiscardOldestPolicy</code>：丢弃队列中最旧的任务，并执行新的任务。</li>
                                    </ul>
                                </td>
                            </tr>
                        </tbody>
                    </table>
                </div>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>线程池的生命周期管理
                </h3>
                <div class="grid md:grid-cols-3 gap-4 mt-6">
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold">shutdown()</h4>
                        <p class="mt-2 text-sm">通过调用线程池的<code>shutdown()</code>方法可以平滑地关闭线程池，它会等待当前正在执行的任务完成后关闭线程池。</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold">shutdownNow()</h4>
                        <p class="mt-2 text-sm">立即关闭线程池，尝试停止所有活动的任务并返回等待执行的任务列表。</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h4 class="font-bold">awaitTermination()</h4>
                        <p class="mt-2 text-sm">等待线程池中所有任务结束，并关闭线程池。可以指定超时时间。</p>
                    </div>
                </div>

                <h3 class="text-2xl font-bold mt-10 flex items-center">
                    <i class="fas fa-circle-notch text-blue-500 mr-3"></i>线程池的扩展与调优
                </h3>
                <p>在实际生产环境中，线程池的合理配置是非常关键的。以下是几个常见的调优方向：</p>
                <ul class="list-disc pl-6 space-y-2 mt-4">
                    <li><strong>线程数的合理设置</strong>：核心线程数和最大线程数的选择应根据机器的CPU核心数和系统的负载能力来合理配置。一般来说，<code>corePoolSize</code>设置为CPU核心数，<code>maximumPoolSize</code>可以设置为核心数的1-2倍，或者根据任务的特性来调整。</li>
                    <li><strong>任务队列的选择</strong>：队列的选择会影响线程池的性能。对于高并发场景，可以选择<code>LinkedBlockingQueue</code>；对于有界队列的场景，可以选择<code>ArrayBlockingQueue</code>。</li>
                    <li><strong>监控与调度</strong>：可以通过JMX监控线程池的运行状态，如当前活动线程数、等待队列大小等，以动态调整线程池的配置。</li>
                </ul>
            </div>
        </section>

        <!-- Concurrency Issues Section -->
        <section id="issues" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="h-px flex-1 bg-gray-300"></div>
                <h2 class="text-3xl font-bold px-4 font-serif">并发编程中的常见问题</h2>
                <div class="h-px flex-1 bg-gray-300"></div>
            </div>
            <div class="prose max-w-none">
                <p class="text-lg leading-relaxed">
                    并发编程为提升系统性能、实现任务并行化和减少响应时间提供了有力的支持，但同时也带来了许多挑战。以下是并发编程中常见的一些问题，这些问题的出现往往影响程序的正确性、性能和可维护性。
                </p>

                <div class="grid md:grid-cols-2 gap-6 mt-10">
                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h3 class="text-xl font-bold flex items-center">
                            <i class="fas fa-running text-red-500 mr-2"></i>竞态条件 (Race Condition)
                        </h3>
                        <p class="mt-2">竞态条件是指两个或更多的线程同时访问和修改共享数据时，结果取决于线程执行的顺序。若没有适当的同步控制，线程的执行顺序无法保证，可能导致不可预测的行为。</p>
                        <div class="mt-4 p-4 bg-gray-50 rounded">
                            <h4 class="font-bold text-sm">解决方法</h4>
                            <ul class="list-disc pl-5 mt-2 text-sm space-y-1">
                                <li>使用互斥锁 (<code>synchronized</code>) 或其他同步机制，如 <code>ReentrantLock</code>，来保证同一时刻只有一个线程可以访问共享资源。</li>
                                <li>使用线程安全的数据结构，如 <code>ConcurrentHashMap</code>，避免显式加锁。</li>
                            </ul>
                        </div>
                    </div>

                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h3 class="text-xl font-bold flex items-center">
                            <i class="fas fa-unlink text-red-500 mr-2"></i>死锁 (Deadlock)
                        </h3>
                        <p class="mt-2">死锁发生在两个或多个线程在执行过程中，因争夺资源而形成一种循环等待的状态，导致这些线程永远无法执行下去。常见的死锁场景是在多个线程获取多个锁时，没有遵循一定的锁顺序。</p>
                        <div class="mt-4 p-4 bg-gray-50 rounded">
                            <h4 class="font-bold text-sm">解决方法</h4>
                            <ul class="list-disc pl-5 mt-2 text-sm space-y-1">
                                <li><strong>锁顺序</strong>：线程获取锁时遵循固定的顺序，避免形成循环等待。</li>
                                <li><strong>锁超时</strong>：使用带超时的锁请求机制，避免长时间等待锁。</li>
                                <li><strong>尝试锁 (tryLock)</strong>：通过 <code>ReentrantLock</code> 的 <code>tryLock()</code> 方法，可以尝试获取锁，如果获取不到，可以放弃或采取其他措施。</li>
                            </ul>
                        </div>
                    </div>

                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h3 class="text-xl font-bold flex items-center">
                            <i class="fas fa-hourglass-half text-yellow-500 mr-2"></i>线程饥饿 (Thread Starvation)
                        </h3>
                        <p class="mt-2">线程饥饿是指某些线程由于优先级过低或长时间无法获取资源而无法得到执行。通常发生在多线程环境中，尤其是使用公平锁或某些线程调度机制时。</p>
                        <div class="mt-4 p-4 bg-gray-50 rounded">
                            <h4 class="font-bold text-sm">解决方法</h4>
                            <ul class="list-disc pl-5 mt-2 text-sm space-y-1">
                                <li>使用公平锁：<code>ReentrantLock</code> 提供了公平锁选项，它能保证线程按照请求的顺序获取锁。</li>
                                <li>动态调整线程的优先级，确保重要线程可以被及时调度。</li>
                            </ul>
                        </div>
                    </div>

                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h3 class="text-xl font-bold flex items-center">
                            <i class="fas fa-sync-alt text-purple-500 mr-2"></i>活锁 (Livelock)
                        </h3>
                        <p class="mt-2">活锁是一种特殊的死锁状态，虽然线程不断尝试执行，但由于不断相互响应而不能完成其任务。与死锁不同，线程仍然在运行，只是没有做任何有意义的工作。</p>
                        <div class="mt-4 p-4 bg-gray-50 rounded">
                            <h4 class="font-bold text-sm">解决方法</h4>
                            <ul class="list-disc pl-5 mt-2 text-sm space-y-1">
                                <li>设置适当的重试机制，避免无意义的线程交互。</li>
                                <li>在设计时，避免线程之间过多的相互依赖和无休止的响应。</li>
                            </ul>
                        </div>
                    </div>

                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h3 class="text-xl font-bold flex items-center">
                            <i class="fas fa-eye text-blue-500 mr-2"></i>内存可见性问题 (Visibility Issues)
                        </h3>
                        <p class="mt-2">当一个线程修改了共享变量的值，而其他线程无法立即看到这个值的变化时，就会发生内存可见性问题。JVM中的指令重排、缓存优化等机制可能导致一个线程对内存的更新对其他线程不可见。</p>
                        <div class="mt-4 p-4 bg-gray-50 rounded">
                            <h4 class="font-bold text-sm">解决方法</h4>
                            <ul class="list-disc pl-5 mt-2 text-sm space-y-1">
                                <li>使用 <code>volatile</code> 关键字，确保变量的可见性。</li>
                                <li>使用适当的同步机制，如 <code>synchronized</code>，确保线程间的内存可见性和有序性。</li>
                            </ul>
                        </div>
                    </div>

                    <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100 card-hover">
                        <h3 class="text-xl font-bold flex items-center">
                            <i class="fas fa-random text-green-500 mr-2"></i>指令重排问题 (Instruction Reordering)
                        </h3>
                        <p class="mt-2">为了提高程序执行的效率，JVM 或硬件可能会对代码中的指令进行重排序，导致并发程序在某些情况下行为不符合预期。例如，在两个线程间访问共享变量时，指令重排可能导致前一个线程的修改尚未被其他线程看到，导致逻辑错误。</p>
                        <div class="mt-4 p-4 bg-gray-50 rounded">
                            <h4 class="font-bold text-sm">解决方法</h4>
                            <ul class="list-disc pl-5 mt-2 text-sm space-y-1">
                                <li>使用 <code>volatile</code> 关键字，它可以禁止指令重排，确保内存操作按顺序进行。</li>
                                <li>使用 <code>synchronized</code> 或其他线程同步机制来避免不必要的重排。</li>
                            </ul>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Diagram Section -->
        <section id="diagram" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="h-px flex-1 bg-gray-300"></div>
                <h2 class="text-3xl font-bold px-4 font-serif">JVM线程与并发图解</h2>
                <div class="h-px flex-1 bg-gray-300"></div>
            </div>
            <div class="diagram-container">
                <div class="mermaid">
                    graph TD
                        A[JVM线程管理] --> B[线程基础]
                        A --> C[线程模型]
                        A --> D[线程调度]
                        A --> E[线程同步]
                        A --> F[线程池]
                        A --> G[并发问题]

                        B --> B1[线程生命周期]
                        B --> B2[线程创建]
                        B --> B3[线程调度]
                        B --> B4[同步机制]

                        C --> C1[线程与OS交互]
                        C --> C2[线程安全模型]
                        C --> C3[内存可见性]

                        D --> D1[调度策略]
                        D --> D2[优先级]
                        D --> D3[时间片]

                        E --> E1[synchronized]
                        E --> E2[Lock]
                        E --> E3[volatile]
                        E --> E4[原子类]

                        F --> F1[ThreadPoolExecutor]
                        F --> F2[核心参数]
                        F --> F3[任务队列]
                        F --> F4[拒绝策略]

                        G --> G1[死锁]
                        G --> G2[竞态条件]
                        G --> G3[内存可见性]
                        G --> G4[线程饥饿]
                </div>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-white py-10">
        <div class="container mx-auto max-w-5xl px-4">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-xl font-bold">技术小馆</h3>
                    <p class="text-gray-400 mt-1">深入技术细节，探索编程艺术</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-blue-400 hover:text-blue-300 transition duration-300">
                        <i class="fas fa-globe mr-2"></i>http://www.yuque.com/jtostring
                    </a>
                </div>
            </div>
            <div class="border-t border-gray-800 mt-8 pt-8 text-center text-gray-400 text-sm">
                <p>© 2023 技术小馆. 版权所有.</p>
            </div>
        </div>
    </footer>

    <script>
        // Initialize Mermaid diagrams
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: false,
                htmlLabels: true,
                curve: 'basis'
            },
            themeVariables: {
                primaryColor: '#3B82F6',
                primaryBorderColor: '#1D4ED8',
                primaryTextColor: '#FFFFFF',
                lineColor: '#9CA3AF',
                secondaryColor: '#EFF6FF',
                tertiaryColor: '#DBEAFE'
            }
        });

        // Smooth scrolling for navigation links
        document.querySelectorAll('a[href^="#"]').forEach(anchor => {
            anchor.addEventListener('click', function (e) {
                e.preventDefault();
                
                const targetId = this.getAttribute('href');
                const targetElement = document.querySelector(targetId);
                
                if (targetElement) {
                    window.scrollTo({
                        top: targetElement.offsetTop - 80,
                        behavior: 'smooth'
                    });
                    
                    // Update URL without refreshing
                    if (history.pushState) {
                        history.pushState(null, null, targetId);
                    } else {
                        window.location.hash = targetId;
                    }
                }
            });
        });

        // Highlight active section in navigation
        window.addEventListener('scroll', function() {
            const scrollPosition = window.scrollY + 100;
            
            document.querySelectorAll('section[id]').forEach(section => {
                const sectionTop = section.offsetTop;
                const sectionHeight = section.offsetHeight;
                const sectionId = section.getAttribute('id');
                
                if (scrollPosition >= sectionTop && scrollPosition < sectionTop + sectionHeight) {
                    document.querySelectorAll('nav a').forEach(link => {
                        link.classList.remove('text-blue-600');
                        link.classList.add('text-gray-700');
                    });
                    
                    const activeLink = document.querySelector(`nav a[href="#${sectionId}"]`);
                    if (activeLink) {
                        activeLink.classList.remove('text-gray-700');
                        activeLink.classList.add('text-blue-600');
                    }
                }
            });
        });
    </script>
</body>
</html>
```